#include <vector>
using namespace std;


class Solution {
public:
    // 思路：滑动窗口法
    // 核心：用两个指针 start 和 end 构成一个窗口 [start, end]，通过移动指针来寻找满足条件的最小窗口
    //
    // 整体过程：
    // 1. 初始化 start=0, min_arr=(数组长度+1), cur_sum=0
    //    min_arr 初始化为一个大于最大可能长度的值，用于后续比较
    //
    // 2. 扩张阶段（移动 end 指针）：
    //    用 for 循环遍历 end 从 0 到 nums.size()-1
    //    在每次循环中，将 nums[end] 加入到 cur_sum 中
    //    这个阶段的目的是不断扩大窗口，直到窗口内的和 cur_sum >= target
    //
    // 3. 收缩阶段（移动 start 指针）：
    //    当 cur_sum >= target 时，进入 while 循环
    //    a. 此时窗口 [start, end] 满足条件，计算其长度 (end - start + 1)
    //    b. 如果这个长度比当前记录的 min_arr 更小，则更新 min_arr
    //    c. 尝试缩小窗口：将 nums[start] 从 cur_sum 中减去，并将 start 指针向右移动一位 (start++)
    //    d. 重复步骤 a-c，直到 cur_sum < target
    //    这个阶段的目的是在满足条件的窗口基础上，尽可能地缩小窗口的左边界，以找到最小的满足条件的窗口
    //
    // 4. 循环往复：
    //    end 指针继续右移，重复步骤 2 和 3，直到 end 遍历完整个数组
    //
    // 5. 结果判断：
    //    遍历结束后，如果 min_arr 的值仍然是初始的 (数组长度+1)，说明没有找到任何满足条件的子数组，返回 0
    //    否则，返回 min_arr，即找到的最小子数组的长度
    //
    // 举例说明（nums = [2, 3, 1, 2, 4, 3], target = 7）：
    // - end=3 时，cur_sum=8 >=7，进入收缩阶段：
    //   * 窗口 [0,3] (长度4)，min_arr=4
    //   * cur_sum=8-2=6，start=1，此时 cur_sum<7，收缩结束
    // - end=4 时，cur_sum=6+4=10 >=7，进入收缩阶段：
    //   * 窗口 [1,4] (长度4)，min_arr仍为4
    //   * cur_sum=10-3=7，start=2，cur_sum仍>=7
    //   * 窗口 [2,4] (长度3)，min_arr=3
    //   * cur_sum=7-1=6，start=3，此时 cur_sum<7，收缩结束
    // - end=5 时，cur_sum=6+3=9 >=7，进入收缩阶段：
    //   * 窗口 [3,5] (长度3)，min_arr仍为3
    //   * cur_sum=9-2=7，start=4，cur_sum仍>=7
    //   * 窗口 [4,5] (长度2)，min_arr=2
    //   * cur_sum=7-4=3，start=5，此时 cur_sum<7，收缩结束
    // 最终 min_arr=2
    int minSubArrayLen(int target, vector<int>& nums) {
        int start = 0;
        int min_arr = nums.size() + 1; // 初始化为一个大于最大可能长度的值
        int cur_sum = 0;

        for (int end = 0; end < nums.size(); end++) {
            cur_sum += nums[end]; // 扩张窗口

            // 当窗口内的和大于等于 target 时，尝试收缩窗口
            while (cur_sum >= target) {
                // 更新最小长度
                if (min_arr > (end - start + 1)) {
                    min_arr = end - start + 1;
                }
                // 收缩窗口：从当前和中减去窗口左边的元素，并移动 start 指针
                cur_sum -= nums[start++];
            }
        }

        // 如果 min_arr 仍为初始值，说明没有找到符合条件的子数组，返回 0
        return min_arr == nums.size() + 1 ? 0 : min_arr;
    }
};